import React, { Component } from 'react';
import './data-tree.css';
import { Modal, Tooltip, message } from 'antd';
import SelectFileForm from '../Modal/select-file-form';
import AddFolderForm from '../Modal/add-folder-form';
import SaveDoc from '../Modal/save-doc';
import SaveDoc1 from '../Modal/save-doc1';

import ExportJsonExcel from 'js-export-excel';

import { getCurvesIntoDao, setEditDepthData, getDaosMb, setDocInReducer, setMbInReducer, isUpdatePages, initmbData } from '../../redux/actions';
import { connect } from 'react-redux';
import {
  reqProcessDocDataList, reqProcessMbData,
  reqSaveData, reqSaveMb, reqSaveDataMb,
} from '../../api';
import { setDocDataList, removeDocDataList } from '../../utils/storageUtils';

// import {DaosListDemo2} from '../../config/daosList';

// const docDatasList = DaosListDemo2;

class DataTree extends Component {
  constructor(props) {
    super(props);
    this.state = {
      expandedKeys: [],
      visible: '0',
      treeData: [],
      curves_mb: [],
      curve_data: [],
    }
  };


  componentDidUpdate(prevProps, prevState) {

    if (prevState.curves_mb !== this.state.curves_mb) {
      this.props.getDaosMb(this.state.curves_mb);   // 将道模板先加载到页面中
      this.props.setMbInReducer(this.state.curve_data);  // 保存当前模板(完整的) :  result.data
      this.props.isUpdatePages(!this.props.updatePages);  // 及时更新页面(导入模板页面)
    }
  }

  addFileShow = () => {    // 添加数据文件 弹框显示
    this.setState({
      visible: '1'
    });
  };
  handleAddDataFile = async () => {    // 添加数据文件 响应函数 (井)
    this.setState({ visible: '0' });
    var docInfo;
    const doc_id = this.formRef.current.getFieldValue('doc_id');
    this.docList.forEach((item) => {
      if (item.doc_id === doc_id) {
        docInfo = item
      }
    });
    const doc_type = docInfo.doc_type;
    const drill_id = docInfo.drill_id;
    const org_id = docInfo.org_id;
    const ws_id = docInfo.ws_id;
    // console.log("选择文件成功",doc_id,docInfo);
    if (doc_type === "纯数据文件") {
      const result = await reqProcessDocDataList(doc_id, doc_type, drill_id, org_id, ws_id);  // 根据文件id获取 数据文件
      console.log("获取纯数据文件result：", result);
      if (result.code === 200) {
        const docDatasList = result.data;
        if (docDatasList.rock_curve) {
          docDatasList.curves.push(docDatasList.rock_curve);    // 将岩性曲线 推入 曲线数组中
        }
        console.log("所有的曲线1：", docDatasList.curves);
        const checkOnLeaf = { key: docInfo.doc_id, title: docInfo.title, type: docDatasList.doc_type, curves: docDatasList.curves };
        const docStartDepth = docDatasList.start_depth;  //文件起深
        const docEndDepth = docDatasList.end_depth;      // 文件终深
        const docInterval = docDatasList.interval;       // 深度间隔
        this.props.setEditDepthData(Number(docStartDepth), Number(docEndDepth), Number(docInterval));   // 读取文件的 起深、终深、深度间隔，并更新
        removeDocDataList();  //清空之前的dataList
        if (checkOnLeaf.curves) {
          if (this.state.curves_mb.length != 0) {  // 用户在选择文件之前已经导入模板
            const data = checkOnLeaf.curves;
            this.props.getCurvesIntoDao(data);  // 将 纯数据曲线 传入模板中  vvvvvvvvv
            this.props.setDocInReducer(docDatasList);  // 将文件保存到reducer  vvvvvvvv
            this.props.isUpdatePages(!this.props.updatePages);  // 及时更新页面(导入模板页面)
            setDocDataList(docDatasList);  // 将获取到的 文件数据 放入内存  
          } else {  // 用户没有选择模板
            if (this.props.defaultmbData.mb_id) {  // 有默认模板,则自动导入默认模板
              const mbData = this.props.defaultmbData;
              const data = checkOnLeaf.curves;
              this.props.getDaosMb(mbData.mb_dao);   // 将 默认模板 载入
              this.props.getCurvesIntoDao(data);  // 将 纯数据曲线 传入模板中  vvvvvvvvv
              this.props.setDocInReducer(docDatasList);  // 将文件保存到reducer  vvvvvvvv
              this.props.setMbInReducer(mbData);  // 保存当前模板(完整的)
              this.props.isUpdatePages(!this.props.updatePages);  // 及时更新页面(导入模板页面)
              setDocDataList(docDatasList);  // 将获取到的 文件数据 放入内存
            } else {
              message.error("请先选择模板或设置默认模板！");
            }
          }
        }
        message.success("选择文件成功")
      } else {
        message.error("数据获取异常！");
      }
    } else if (docInfo.doc_type === "绘图文件") {
      const result = await reqProcessDocDataList(doc_id, doc_type, drill_id, org_id, ws_id);  // 根据文件id获取 绘图文件
      // console.log("绘图文件",result);
      if (result.code === 200) {
        const docDatasList = result.data;
        docDatasList.docData.curves.push(docDatasList.docData.rock_curve);   // 将岩性曲线 放入 曲线数组中
        const checkOnLeaf = { key: docInfo.doc_id, title: docInfo.title, type: docDatasList.doc_type, curves: docDatasList.docData.curves };
        const docStartDepth = docDatasList.docData.start_depth;  //文件起深
        const docEndDepth = docDatasList.docData.end_depth;      // 文件终深
        const docInterval = docDatasList.docData.interval;       // 深度间隔
        this.props.setEditDepthData(Number(docStartDepth), Number(docEndDepth), Number(docInterval));   // 读取文件的 起深、终深、深度间隔，并更新
        removeDocDataList();  //清空之前的dataList
        if (checkOnLeaf.curves) {
          if (this.state.curves_mb.length === 0) {  // 没有导入模板     
            //1、导入模板mbData
            const mbData = docDatasList.mbData;
            this.props.getDaosMb(mbData.mb_dao);   // 将 绘图文件 的 模板部分 先载入
            //2、导入数据docData
            const docData = docDatasList.docData;
            this.props.getCurvesIntoDao(docData.curves);    // 将 绘图文件 的 纯数据部分 载入  vvvvvvvv
            this.props.setDocInReducer(docDatasList);  // 将绘图文件保存到reducer  vvvvvvvvvvvv
            this.props.setMbInReducer(mbData);  // 保存当前模板(完整的)
            this.props.isUpdatePages(!this.props.updatePages);  // 及时更新页面(导入模板页面)
            setDocDataList(docDatasList);  // 将获取到的 绘图文件数据 放入内存
            //console.log("绘图文件",mbData,docData)
          } else {
            message.error("请勿导入模板！");
          }
        }
        message.success("选择文件成功")
      } else {
        message.error("数据获取异常！");
      }
    }
  };

  addFolderShow = () => {    // 添加模板 弹框显示
    this.setState({
      visible: '2'
    });
  };

  handleAddFolder = async () => {    // 添加模板 响应函数     
    this.setState({ visible: '0' });
    const mb_id = this.formRef.current.getFieldValue('mb_id');
    const result = await reqProcessMbData(mb_id);
    // console.log("获取模板",result) 
    if (result.code === 200) {
      const curves_mb = result.data.mb_dao;
      this.props.initmbData({});
      // console.log(this.props.mbData)
      // this.props.getDaosMb(curves_mb);   // 将道模板先加载到页面中
      // this.props.setMbInReducer(result.data);  // 保存当前模板(完整的) :  result.data
      // this.props.isUpdatePages(!this.props.updatePages);  // 及时更新页面(导入模板页面)
      this.setState({
        curves_mb,
        curve_data: result.data
      })
    } else {
      message.error("模板获取失败！");
    }
  };

  saveDocShow = () => {    // 保存 弹框显示
    this.setState({
      visible: '3'
    });
  };
  saveDoc1Show = () => {    // 另存为 文件 弹框显示
    this.setState({
      visible: '4'
    });
  };
  handleSaveDoc = async (saveType) => {   // 保存文件 响应函数  !!!!!!
    this.setState({ visible: '0' });
    const type1 = this.formRef.current.getFieldValue('radio_group');     // type1: 仅数据、仅模板、模板+数据
    var another_name;   // 另存为中的 修改后的 文件名称
    if (saveType === 'another_save') {
      another_name = this.formRef.current.getFieldValue('doc_name');
    }

    const oldData = JSON.parse(JSON.stringify(this.props.daosDataList));   // 获取当前页面中的 模板+数据, 深拷贝！！！！！！！！！
    var docInfo = JSON.parse(JSON.stringify(this.props.docData)); //  当前文件信息：数据文件、绘图文件
    var mbInfo = JSON.parse(JSON.stringify(this.props.mbData));   // 当前模板信息

    console.log("保存saveType,type1,another_name,olddata,docInfo,mbInfo", saveType, type1, another_name, oldData, docInfo, mbInfo);
    var data = [];  // 普通曲线
    var rockData = {};  // 岩性曲线
    //console.log("当前模板+数据",oldData);
    /*
       1、保存纯数据文件：
           1.1、 数据存数据
               1.1.1、保存
               1.1.2、另存为
           1.2、 绘图存数据
           1.3、 无文件存数据
       2、保存模板：
           2.1、数据存模板
           2.2、绘图存模板
           2.3、模板存模板
           2.4、无模板存模板
       3、保存绘图文件：
           3.1、数据存绘图
           3.2、绘图存绘图
           3.3、无文件存绘图
    */
    if (type1 === 'data') {    //保存 纯数据文件
      if (docInfo.doc_type === "纯数据文件") {   // 导入数据文件，保存数据文件
        oldData.forEach((item1) => {   // 从 模板+数据 中 取出数据
          if (item1.curves) {
            item1.curves.forEach((item2) => {
              if (item2.id !== null) {  // curve_id 说明这里是有曲线数据的，不是只有曲线属性
                if (item2.type === 'curve') {
                  const dataItem = {
                    curve_id: item2.curve_id,
                    curve_name: item2.curve_name,
                    type: item2.type,
                    xData: item2.xData,
                  }
                  data.push(dataItem);
                } else {  // 岩性曲线
                  rockData = item2;
                }
              }
            })
          }
        });
        // 补全曲线
        var isHaveCurve = false;  // 文件中的曲线和模板未匹配
        if (data.length === 0) {  // 如果文件和模板的曲线匹配为0；
          docInfo.curves.forEach((item) => {
            if (item.type === 'curve') {
              data.push(item)
            } else {
              rockData = item
            }
          })
        }
        else {   // 文件和模板中的曲线匹配了，但有可能存在 未匹配的
          docInfo.curves.forEach((item1) => {
            isHaveCurve = false;
            data.forEach((item2) => {
              if (item2.curve_id === item1.curve_id) {  // data中已有该曲线
                isHaveCurve = true
              }
            })
            if (rockData && item1.curve_id === rockData.curve_id) {
              isHaveCurve = true
            }
            if (isHaveCurve === false) {   // 将 未匹配的曲线 放入data中
              if (item1.type === 'curve') {
                data.push(item1);
              } else {
                rockData = item1
              }
            }
          })
        }

        // 判断保存类型
        if (saveType === 'save') {
          docInfo.curves = data;
          docInfo.rock_curve = rockData;
        } else {
          docInfo.curves = data;
          docInfo.rock_curve = rockData;
          docInfo.title = another_name;
        }
        console.log("数据存数据", saveType, docInfo);
        const result = await reqSaveData(saveType, docInfo);  //  √√√√
        console.log("数据存数据result", result);
        if (result.code === 200) {
          message.success("保存成功！")   // vvvvvvvvv
        } else {
          message.error("保存失败！")
        }
      } else if (docInfo.doc_type === "绘图文件") {   // 导入绘图文件，保存数据文件
        oldData.forEach((item1) => {   // 从 模板+数据 中 取出数据
          if (item1.curves) {
            item1.curves.forEach((item2) => {
              if (item2.curve_id !== null) {  // 说明这里是有曲线数据的，不是只有曲线属性
                if (item2.type === 'curve') {
                  const dataItem = {
                    curve_id: item2.curve_id,
                    curve_name: item2.curve_name,
                    type: item2.type,
                    xData: item2.xData,
                  }
                  data.push(dataItem);
                } else {  // 岩性曲线
                  rockData = item2
                }
              }
            })
          }
        });
        // 补全曲线
        var isHaveCurve = false;  // 文件中的曲线和模板未匹配
        if (data.length === 0) {  // 如果文件和模板的曲线匹配为0；
          docInfo.docData.curves.forEach((item) => {
            if (item.type === 'curve') {
              data.push(item)
            } else {
              rockData = item
            }
          })
        } else {   // 文件和模板中的曲线匹配了，但有可能存在 未匹配的
          docInfo.docData.curves.forEach((item1) => {
            isHaveCurve = false;
            data.forEach((item2) => {
              if (item2.curve_id === item1.curve_id) {  // data中已有该曲线
                isHaveCurve = true
              }
            })
            if (rockData && item1.curve_id === rockData.curve_id) {
              isHaveCurve = true
            }
            if (isHaveCurve === false) {   // 将 未匹配的曲线 放入data中
              if (item1.type === 'curve') {
                data.push(item1);
              } else {
                rockData = item1
              }
            }
          })
        }
        // 判断保存类型
        if (saveType === 'save') {
          docInfo.docData.curves = data;
          docInfo.docData.rock_curve = rockData;
        } else {
          docInfo.docData.curves = data;
          docInfo.docData.rock_curve = rockData;
          docInfo.docData.title = another_name;
        }
        console.log("绘图存数据", saveType, docInfo.docData);
        const result = await reqSaveData(saveType, docInfo.docData);
        console.log("绘图存数据result", result);
        if (result.code === 200) {
          message.success("保存成功！");   // vvvvvvvvvvvvv
        } else {
          message.error("保存失败！");
        }
      } else {  // 没有导入 文件（只有模板或什么都没有）
        message.error("请先导入文件！");    // vvvvvvvvvv
      }
    } else if (type1 === 'mb') {   // 保存模板
      if (docInfo.doc_type === "纯数据文件") {   // 数据+模板 存模板
        oldData.forEach((item1) => {  // 从 数据+模板 中 取出模板
          if (item1.curves) {
            item1.curves.forEach((item2) => {   // 清空模板中的 曲线, 将 曲线id与name改回一致
              item2.curve_id = null;
              item2.xData = [];
            })
          }
        });
        if (saveType === 'save') {
          mbInfo.mb_dao = oldData;
        } else {
          mbInfo.mb_dao = oldData;
          mbInfo.mb_name = another_name;
        }
        const mb_id = mbInfo.mb_id;
        const mb_name = mbInfo.mb_name;
        const mb_dao = mbInfo.mb_dao;
        console.log("数据存模板", saveType, mb_id, mb_name, mb_dao);
        const result = await reqSaveMb(saveType, mb_id, mb_name, mb_dao);
        if (result.code === 200) {
          message.success("保存成功！");   // vvvvvvvvvvvvvvv
        } else {
          message.error("保存失败！");
        }
      } else if (docInfo.doc_type === "绘图文件") {  // 绘图存模板
        oldData.forEach((item1) => {  // 从 数据+模板 中 取出模板
          if (item1.curves) {
            item1.curves.forEach((item2) => {   // 清空模板中的 曲线, 将 曲线id与name改回一致
              item2.curve_id = null;
              item2.xData = [];
            })
          }
        });
        if (saveType === 'save') {
          docInfo.mbData.mb_dao = oldData;
        } else {
          docInfo.mbData.mb_dao = oldData;
          docInfo.mbData.mb_name = another_name;
        }
        const mb_id = docInfo.original_mb;
        const mb_name = docInfo.mbData.mb_name;
        const mb_dao = docInfo.mbData.mb_dao;
        console.log("绘图存模板", saveType, mb_id, mb_name, mb_dao);  // 原始模板id，保存的模板，保存类型
        const result = await reqSaveMb(saveType, mb_id, mb_name, mb_dao);
        console.log("绘图存模板result", result);
        if (result.code === 200) {
          message.success("保存成功！");   // vvvvvvvvvvvvv
        } else {
          message.error("保存失败！");
        }
      } else if (mbInfo.mb_id) {  // 没有导入文件，只导入模板 存模板   ????????????????????????????????????????????????
        if (saveType === 'save') {
          mbInfo.mb_dao = oldData
        } else {
          mbInfo.mb_dao = oldData;
          mbInfo.mb_name = another_name;
        }
        const mb_id = mbInfo.mb_id;
        const mb_name = mbInfo.mb_name;
        const mb_dao = mbInfo.mb_dao;
        console.log("模板存模板", saveType, mb_id, mb_name, mb_dao);
        const result = await reqSaveMb(saveType, mb_id, mb_name, mb_dao);
        console.log("模板存模板 result", result);
        if (result.code === 200) {
          message.success("保存成功！")   // vvvvvvvvvvvvv
        } else {
          message.error("保存失败！")
        }
      } else {                 // 没有导入模板
        message.error("请先导入模板！");    // vvvvvvvvvvv
      }
    } else if (type1 === 'data+mb') {  // 保存绘图文件
      if (docInfo.doc_type === '纯数据文件') {  // 数据 存 绘图
        var newMbData = JSON.parse(JSON.stringify(oldData));
        //console.log("数据存绘图oldData",oldData);
        oldData.forEach((item1) => {   // 从 模板+数据 中 取出数据
          if (item1.curves) {
            item1.curves.forEach((item2) => {
              if (item2.curve_id !== null) {  // 说明这里是有曲线数据的，不是只有曲线属性
                if (item2.type === 'curve') {
                  const dataItem = {
                    curve_id: item2.curve_id,
                    curve_name: item2.curve_name,
                    type: item2.type,
                    xData: item2.xData,
                  }
                  data.push(dataItem);
                } else {  // 岩性曲线
                  rockData = item2
                }
              }
            })
          }
        });
        // 补全曲线
        var isHaveCurve = false;  // 文件中的曲线和模板未匹配
        if (data.length === 0) {  // 如果文件和模板的曲线匹配为0；
          docInfo.curves.forEach((item) => {
            if (item.type === 'curve') {
              data.push(item)
            } else {
              rockData = item
            }
          })
        } else {   // 文件和模板中的曲线匹配了，但有可能存在 未匹配的
          docInfo.curves.forEach((item1) => {
            isHaveCurve = false;
            data.forEach((item2) => {
              if (item2.curve_id === item1.curve_id) {  // data中已有该曲线
                isHaveCurve = true
              }
            })
            if (rockData && item1.curve_id === rockData.curve_id) {
              isHaveCurve = true
            }
            if (isHaveCurve === false) {   // 将 未匹配的曲线 放入data中
              if (item1.type === 'curve') {
                data.push(item1);
              } else {
                rockData = item1
              }
            }
          })
        }
        // 取出模板
        newMbData.forEach((item1) => {  // 从 数据+模板 中 取出模板
          if (item1.curves) {
            item1.curves.forEach((item2) => {   // 清空模板中的 曲线, 将 曲线id与name改回一致
              item2.curve_id = null;
              item2.xData = [];
            })
          }
        });
        var title;  //绘图文件的名称
        if (saveType === 'save') {   // 数据 存 绘图，本质上为 同名另存为绘图
          // message.error("绘图文件无法覆盖数据文件！");
          docInfo.curves = data;
          docInfo.rock_curve = rockData;
          mbInfo.mb_dao = newMbData;
          title = docInfo.title + '绘图';  // 绘图文件覆盖数据文件，仍使用数据文件的id和title
        } else {  // 数据另存绘图
          docInfo.curves = data;
          docInfo.rock_curve = rockData;
          mbInfo.mb_dao = newMbData;
          title = another_name;
        }
        // const drill_id = docInfo.drill_id; 
        // console.log("huituwenjian",docInfo);  
        // const original_file = docInfo.doc_id;
        // const original_mb = mbInfo.mb_id;
        // const doc_id = docInfo.doc_id;  // 如果覆盖，那么就是用 该数据文件id，如果另存，获取不到新id，后台新建id
        // const doc_type = "绘图文件";
        // const docData = docInfo;
        // const mbData = mbInfo;
        var drawDocument = {
          org_id: docInfo.org_id,
          ws_id: docInfo.ws_id,
          drill_id: docInfo.drill_id,
          doc_id: docInfo.doc_id,  // 如果覆盖，那么就是用 该数据文件id，如果另存，获取不到新id，后台新建id
          doc_type: '绘图文件',
          title: title,
          original_file: docInfo.doc_id,  // 原始文件id
          original_mb: mbInfo.mb_id,  // 原始模板id
          docData: docInfo,
          mbData: mbInfo
        }
        console.log("数据存绘图", saveType, drawDocument);  //mbData
        const result = await reqSaveDataMb(saveType, drawDocument);
        console.log("数据存绘图", result);
        if (result.code === 200) {
          message.success("保存成功！")   // vvvvvvvvv
        } else {
          message.error("保存失败！")
        }
      } else if (docInfo.doc_type === '绘图文件') {   // 绘图存绘图
        var newMbData = JSON.parse(JSON.stringify(oldData));
        oldData.forEach((item1) => {   // 从 模板+数据 中 取出数据
          if (item1.curves) {
            item1.curves.forEach((item2) => {
              if (item2.curve_id !== null) {  // 说明这里是有曲线数据的，不是只有曲线属性
                if (item2.type === 'curve') {
                  const dataItem = {
                    curve_id: item2.curve_id,
                    curve_name: item2.curve_name,
                    type: item2.type,
                    xData: item2.xData,
                  }
                  data.push(dataItem);
                } else {  // 岩性曲线
                  rockData = item2
                }
              }
            })
          }
        });
        // 补全曲线
        var isHaveCurve = false;  // 文件中的曲线和模板未匹配
        if (data.length === 0) {  // 如果文件和模板的曲线匹配为0；
          docInfo.docData.curves.forEach((item) => {
            if (item.type === 'curve') {
              data.push(item)
            } else {
              rockData = item
            }
          })
        } else {   // 文件和模板中的曲线匹配了，但有可能存在 未匹配的
          docInfo.docData.curves.forEach((item1) => {
            isHaveCurve = false;
            data.forEach((item2) => {
              if (item2.curve_id === item1.curve_id) {  // data中已有该曲线
                isHaveCurve = true
              }
            })
            if (rockData && item1.curve_id === rockData.curve_id) {
              isHaveCurve = true
            }
            if (isHaveCurve === false) {   // 将 未匹配的曲线 放入data中
              if (item1.type === 'curve') {
                data.push(item1);
              } else {
                rockData = item1
              }
            }
          })
        }
        newMbData.forEach((item1) => {  // 从 数据+模板 中 取出模板
          if (item1.curves) {
            item1.curves.forEach((item2) => {   // 清空模板中的 曲线, 将 曲线id与name改回一致
              item2.curve_id = null;
              item2.xData = [];
            })
          }
        });
        if (saveType === 'save') {
          docInfo.docData.curves = data;
          docInfo.docData.rock_curve = rockData;
          docInfo.mbData.mb_dao = newMbData;
        } else {
          docInfo.docData.curves = data;
          docInfo.docData.rock_curve = rockData;
          docInfo.mbData.mb_dao = newMbData;
          docInfo.title = another_name;
        }
        // const original_file = docInfo.original_file;
        // const original_mb = docInfo.original_mb;
        // const doc_id = docInfo.doc_id;  
        // const doc_type = docInfo.doc_type;
        // const title = docInfo.title;
        // const docData = docInfo.docData;
        // const mbData = docInfo.mbData;
        // const drill_id = docInfo.drill_id;  

        var drawDocument = {
          org_id: docInfo.org_id,
          ws_id: docInfo.ws_id,
          drill_id: docInfo.drill_id,
          doc_id: docInfo.doc_id,  // 如果覆盖，那么就是用 该数据文件id，如果另存，获取不到新id，后台新建id
          doc_type: docInfo.doc_type,
          title: docInfo.title,
          original_file: docInfo.original_file,  // 原始文件id
          original_mb: docInfo.original_mb,  // 原始模板id
          docData: docInfo.docData,
          mbData: docInfo.mbData
        }
        console.log("绘图存绘图", saveType, drawDocument);
        const result = await reqSaveDataMb(saveType, drawDocument);
        console.log("绘图存绘图result", result);
        if (result.code === 200) {
          message.success("保存成功!");  //vvvvvvvvvvvvvvvvvvvv
        } else {
          message.error("保存失败！");
        }
      } else {  // 无文件
        message.error("请先导入文件！");
      }
    } else {
      message.error("请选择保存类型！");
    }
  };

  handleCancel = () => {    // 对话框取消按钮
    this.setState({
      visible: '0'
    });
  };


  exportExcel = () => {
    const data = this.props.daosDataList ? this.props.daosDataList : '';
    console.log(this.props)
    let newXData = [];
    data.forEach(item => {
      if (item.type == "yx-dao") {
        let xData = item.curves[0].xData;
        let depthArr = [];

        //1.将xData的数据导入到数组中去重
        xData.forEach(el => {
          for (let i = el.start_depth; i <= el.end_depth; i++) {
            depthArr[i] = el.yx_id
          }
        })
        // console.log(depthArr);

        //2.用将数组填充满
        for (let i = 0; i < this.props.depthDataa.length; i++) {
          if (depthArr[i] == undefined || depthArr[i] == null) {
            depthArr[i] = 'rock_null'
          }
        }
        // console.log(depthArr);

        //3.将数组再次转化为xData的形式
        let rock_temp = 'rock_null', start = 0, order = 0;
        for (let i = 0; i < this.props.depthDataa.length; i++) {
          if (depthArr[i] != rock_temp) {
            newXData.push({
              order: order,
              start_depth: start,
              end_depth: i - 1,
              yx_id: depthArr[i - 1]
            })
            order++;
            start = i;
            rock_temp = depthArr[i];
          }
        }
        if (rock_temp == 'rock_null') {
          newXData.push({
            order: order,
            start_depth: start,
            end_depth: parseInt(this.props.docData.end_depth),
            yx_id: 'rock_null'
          })
        }
        newXData.shift()
        // console.log(start,newXData);
      }
    })

    //4.新增伽马参数
    data.forEach(item => {
      if (item.type == "line-dao" && item.curves.length != 0) {
        item.curves.forEach(el => {
          if (el.curve_name == '伽马') {

            newXData.forEach((el_sub, index) => {
              let sum = 0, start_index = 0, end_index = 0;

              //在深度道找对应的下标，然后在伽马曲线中对应
              this.props.docData.yData.forEach((tmp, index) => {
                if (tmp == el_sub.start_depth) {
                  start_index = index
                }
                if (tmp == el_sub.end_depth) {
                  end_index = index
                }
              })
              console.log("---起始坐标----终止坐标---", start_index, end_index)

              for (let i = start_index; i < end_index; i++) {
                sum += el.xData[i];
              }
              console.log(sum)
              newXData[index].gama = parseFloat(sum / (end_index - start_index)).toFixed(2);
            })
            // console.log(newXData)
          }
        })
      }
    })
    console.log(newXData)
    newXData.forEach(item => {
      item.yx_name = this.transformYxName(item.yx_id)
    })
    // const data = this.props.OriginData.originData ? this.props.OriginData.originData : '';//表格数据
    // console.log(data);
    var option = {};

    let fileName = this.props.docData ? this.props.docData.title.split(".")[0] : ""
    option.fileName = fileName + '_解释成果表'
    let header = ["序号", "开始深度(m)", "结束深度(m)", "伽马平均值", "岩性"];
    let strArr = ["order", "start_depth", "end_depth", "gama", "yx_name"];

    // //删除无用列，后端处理返回数据后可以注释
    // let index1=strArr.indexOf('deleted');
    // strArr.splice(index1,1);
    // let index2=strArr.indexOf('key');
    // strArr.splice(index2,1);

    // console.log(strArr)
    option.datas = [
      {
        sheetData: newXData,
        sheetName: 'sheet',
        sheetFilter: strArr,
        sheetHeader: header,
        columnWidths: [3, 5, 5, 5, 5],
      }
    ];

    var toExcel = new ExportJsonExcel(option);
    toExcel.saveExcel();
  }

  transformYxName = (type) => {
    if (type === 'rock_null') { return '' }
    else if (type === 'rock-1') { return '白云岩' }
    else if (type === 'rock-2') { return '粗砂岩' }
    else if (type === 'rock-3') { return '粉砂岩' }
    else if (type === 'rock-4') { return '钙质砂岩' }
    else if (type === 'rock-5') { return '钙质页岩' }
    else if (type === 'rock-6') { return '钙质粘土' }
    else if (type === 'rock-7') { return '黄土' }
    else if (type === 'rock-8') { return '灰岩' }
    else if (type === 'rock-9') { return '角砾岩' }
    else if (type === 'rock-10') { return '中砂岩' }

    else if (type === 'rock-11') { return '砾岩' }
    else if (type === 'rock-12') { return '煤' }
    else if (type === 'rock-13') { return '泥灰岩' }
    else if (type === 'rock-14') { return '泥质白云岩' }
    else if (type === 'rock-15') { return '泥质粉砂岩' }
    else if (type === 'rock-16') { return '泥质灰岩' }
    else if (type === 'rock-17') { return '泥质砂岩' }
    else if (type === 'rock-18') { return '凝灰质砂岩' }
    else if (type === 'rock-19') { return '砂砾石' }
    else if (type === 'rock-20') { return '砾石' }

    else if (type === 'rock-21') { return '砂质泥灰岩' }
    else if (type === 'rock-22') { return '砂质页岩' }
    else if (type === 'rock-23') { return '碳质灰岩' }
    else if (type === 'rock-24') { return '碳质页岩' }
    else if (type === 'rock-25') { return '碳质粘土' }
    else if (type === 'rock-26') { return '填筑土' }
    else if (type === 'rock-27') { return '细砂岩' }
    else if (type === 'rock-28') { return '页岩' }
    else if (type === 'rock-29') { return '粘土' }
    else if (type === 'rock-30') { return '粘土岩(泥质)' }
  }

  render() {
    const { visible, expandedKeys, treeData } = this.state;
    return (
      <div className="data-tree-wrapper">
        <div className="data-file-title">
          {/* <i className="iconfont iconfont-left">&#xe622;</i>
          <Input 
            className="data-search"
            placeholder="搜索..." 
            bordered={false} 
            onChange={value => console.log(value)}
          /> */}
          <Tooltip placement="bottom" title='数据文件' overlayStyle={{ fontSize: 12 }}>
            <img className='iconfont' src={require('../../assets/image/new.png')} onClick={this.addFileShow} alt="" />
          </Tooltip>
          <Tooltip placement="bottom" title='模板' overlayStyle={{ fontSize: 12 }}>
            <img className='iconfont' src={require('../../assets/image/addTemplate.png')} onClick={this.addFolderShow} alt="" />
          </Tooltip>
          <Tooltip placement="bottom" title='保存' overlayStyle={{ fontSize: 12 }}>
            <img className='iconfont' src={require('../../assets/image/save.png')} alt="" onClick={this.saveDocShow}/>
          </Tooltip>
          <Tooltip placement="bottom" title='另存为' overlayStyle={{ fontSize: 12 }}>
            <img className='iconfont' src={require('../../assets/image/saveAs.png')} alt="" onClick={this.saveDoc1Show}/>
          </Tooltip>
          <Tooltip placement="bottom" title='导出为图片' overlayStyle={{ fontSize: 12 }}>
            {/* 从data-process.js传过来的函数 */}
            <img className='iconfont' src={require('../../assets/image/exportPic.png')} alt="" onClick={this.props.handleReturnTop}/>
          </Tooltip>
          <Tooltip placement="bottom" title='导出为Excel' overlayStyle={{ fontSize: 12 }}>
            {/* 从data-process.js传过来的函数 */}
            <img className='iconfont' src={require('../../assets/image/exportExcel.png')} alt="" onClick={this.exportExcel}/>
          </Tooltip>

        </div>

        {/* <DirectoryTree
          className="tree-file"
          defaultExpandedKeys={expandedKeys}   // 默认展开所有树节点
          draggable
          onSelect={this.onSelect}  // 选中该条选项
          treeData={treeData}   // tree的数据来源  
        > 
        </DirectoryTree> */}

        <Modal
        className='data-tree-dialog'
          title="添加数据文件"
          visible={visible === '1'}
          onOk={this.handleAddDataFile}
          onCancel={this.handleCancel}
          destroyOnClose={true}  // 关闭时销毁子元素
          okText="确定"
          cancelText="取消"
        >
          <SelectFileForm
            setForm={(formRef) => { this.formRef = formRef }}
            setDocList={(docList) => { this.docList = docList }}
          />
        </Modal>

        <Modal
        className='data-tree-dialog'
          title="添加模板"
          visible={visible === '2'}
          onOk={this.handleAddFolder}
          onCancel={this.handleCancel}
          okText="确定"
          cancelText="取消"
          destroyOnClose={true}
        >
          <AddFolderForm setForm={(formRef) => { this.formRef = formRef }} />
        </Modal>

        <Modal
        className='data-tree-dialog'
          title="保存"
          visible={visible === '3'}
          onOk={() => this.handleSaveDoc('save')}   // 保存，另存为两个按钮
          onCancel={this.handleCancel}
          okText="确定"
          cancelText="取消"
          destroyOnClose={true}
        >
          <SaveDoc setForm={(formRef) => { this.formRef = formRef }} />
        </Modal>

        <Modal
        className='data-tree-dialog'
          title="另存为"
          visible={visible === '4'}
          onOk={() => this.handleSaveDoc('another_save')}
          onCancel={this.handleCancel}
          okText="确定"
          cancelText="取消"
          destroyOnClose={true}
        >
          <SaveDoc1
            docInfo={this.props.docData}
            setForm={(formRef) => { this.formRef = formRef }} />
        </Modal>
      </div>
    )
  }
}

export default connect(
  state => ({
    docData: state.docData, daosDataList: state.daosDataList, mbData: state.mbData, defaultmbData: state.defaultmbData,
    updatePages: state.updatePages, depthDataa: state.depthDataa
  }),// 用来显示
  { getCurvesIntoDao, setEditDepthData, getDaosMb, setDocInReducer, setMbInReducer, isUpdatePages, initmbData }  // 用来更新
)(DataTree);

